package com.xhh.nphm.gaoxin.service.impl;

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.xhh.nphm.common.annotation.DataSource;
import com.xhh.nphm.common.constant.Constants;
import com.xhh.nphm.common.core.domain.QueryConditionVo;
import com.xhh.nphm.common.utils.DateUtils;
import com.xhh.nphm.common.utils.MapDataUtil;
import com.xhh.nphm.gaoxin.entity.GxqMuReplyWaitTelExcel;
import com.xhh.nphm.gaoxin.entity.GxqTwfSendBackEty;
import com.xhh.nphm.gaoxin.mapper.GxqWfSendBackDao;
import com.xhh.nphm.gaoxin.service.GxqIWfSendBackService;
import com.xhh.nphm.system.domain.*;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Service;

import java.util.*;

@Service
public class GxqWfSendBackServiceImpl extends ServiceImpl<com.xhh.nphm.gaoxin.mapper.GxqWfSendBackDao, GxqTwfSendBackEty> implements GxqIWfSendBackService {

    @Autowired
    private GxqWfSendBackDao GxqWfSendBackDao;

    @Value("${employ.location}")
    private String location;

    /**
     *  新增电话派单
     * @param GxqTwfSendBackEty
     * @return
     */
    @Override
    public int insert(GxqTwfSendBackEty GxqTwfSendBackEty) {
        return GxqWfSendBackDao.insert(GxqTwfSendBackEty);
    }

    /**
     * 根据工单id查询电话派单数据
     *
     * @param wfId
     * @return
     */
    @Override
    public List<GxqTwfSendBackEty> selectByWfId(Integer wfId) {
        return GxqWfSendBackDao.selectByWfIdList(wfId);
    }

    @Override
    public GxqTwfSendBackEty selectByGetDealPk(Integer id) {
        return GxqWfSendBackDao.selectByGetDealPk(id);
    }

    @Override
    public int updateSendBack(GxqTwfSendBackEty GxqTwfSendBackEty) {
        return GxqWfSendBackDao.updateById(GxqTwfSendBackEty);
    }

    /**
     * 根据派单id 查询单个派单记录
     * @param wfId
     * @return
     */
    @Override
    public GxqTwfSendBackEty getByWfId(Integer wfId) {
        return GxqWfSendBackDao.getByWfId(wfId);
    }

    /**
     * 修改退回审核 派单状态
     * @param sendRemark
     * @param backState
     * @param pkId 派单id
     * @return
     */
    @Override
    public int updateTwfSendBack(String sendRemark,Integer backState,Integer pkId) {
        return GxqWfSendBackDao.updateTwfSendBack(sendRemark,backState,pkId);
    }



    @Override
    public GxqTwfSendBackEty selectByPkId(Integer sid) {
        return GxqWfSendBackDao.selectByPkId(sid);
    }

    /**
     * 调整承办部门 列表数据
     *
     * @return
     */
    @Override
    public List<GxqTwfSendBackEty> sendBackListJson(GxqTwfSendBackEty GxqTwfSendBackEty) {
        return GxqWfSendBackDao.sendBackListJson(GxqTwfSendBackEty);
    }

    /**
     * 下级退回电话工单审核 列表
     * @param GxqTwfSendBackEty
     * @return
     */
    @Override
    public List<GxqTwfSendBackEty> treturnFlowJson(GxqTwfSendBackEty GxqTwfSendBackEty, String deptNo) {
        List<GxqTwfSendBackEty> list = GxqWfSendBackDao.treturnFlowJson(GxqTwfSendBackEty, deptNo);
        return list;
    }

    /**
     * 根据id 进行多选删除 和单个删除
     * @param ids
     * @return
     */
    @Override
    public int deleteByIds(String[] ids) {
        return GxqWfSendBackDao.deleteBatchIds(Arrays.asList(ids));
    }

    /**
     * 查找待本部门回复的工单数据
     *
     * @param deptId 部门id
     * @return 工单列表数据
     */
    @Override
    public List<Map<String,Object>> muReplyWaitJson(Long deptId,QueryConditionVo qc) {
        List<Map<String, Object>> maps = new ArrayList<>();
        if(location.equals("jjq")){
            maps = GxqWfSendBackDao.muReplyWaitJson_jjq(MapDataUtil.multiTypeParamListToMap(qc,String.valueOf(deptId)));
        }else if(location.equals("px")){
            maps = GxqWfSendBackDao.muReplyWaitJson_px(MapDataUtil.multiTypeParamListToMap(qc,String.valueOf(deptId)));
        }
        return maps;
    }

    /**
     * 查找待本部门回复的工单数据导出
     *
     * @param deptId 部门id
     * @return 工单列表数据
     */
    @Override
    public List<GxqMuReplyWaitTelExcel> muReplyWaitJsonExport(Long deptId, QueryConditionVo qc) {
        List<GxqMuReplyWaitTelExcel> maps = new ArrayList<>();
        if(location.equals("jjq")){
            maps = GxqWfSendBackDao.muReplyWaitJson_jjqExport(MapDataUtil.multiTypeParamListToMap(qc,String.valueOf(deptId)));
        }else if(location.equals("px")){
            maps = GxqWfSendBackDao.muReplyWaitJson_pxExport(MapDataUtil.multiTypeParamListToMap(qc,String.valueOf(deptId)));
        }
        return maps;
    }

    /**
     * 市级未签收列表数据
     * @param GxqTwfSendBackEty
     * @param
     * @return
     */
    @Override
    public List<GxqTwfSendBackEty> muSignNotJson(GxqTwfSendBackEty GxqTwfSendBackEty, String deptId) {
        return GxqWfSendBackDao.muSignNotJson(GxqTwfSendBackEty,deptId);
    }

    @Override
    public List<GxqTwfSendBackEty> muSignNotJson_gxq(GxqTwfSendBackEty GxqTwfSendBackEty, String deptId) {
        return GxqWfSendBackDao.muSignNotJson_gxq(GxqTwfSendBackEty,deptId);
    }

    /**
     * 查找审核本级回复的工单数据
     *
     * @param deptId     部门id
     * @param workFormNo
     * @param sdeptName
     * @return 工单列表数据
     */
    @Override
    public List<Map<String, Object>> muReplyChkJson(Long deptId, String workFormNo, String sdeptName) {
        return GxqWfSendBackDao.muReplyChkJson(deptId,workFormNo,sdeptName);
    }

    /**
     * 查找本部门已办毕的工单数据
     *
     * @param deptId     部门id
     * @param workFormNo 工单编号
     * @param sdeptName  派发单位
     * @return 工单列表数据
     */
    @Override
    public List<Map<String, Object>> muReplyOverJson(Long deptId, String workFormNo, String sdeptName) {
        return GxqWfSendBackDao.muReplyOverJson(String.valueOf(deptId),workFormNo,sdeptName);
    }

    /**
     * 查找本部门退回的工单数据
     *
     * @param deptId     部门id
     * @param workFormNo 工单编号
     * @param sdeptName  派发单位
     * @return 工单列表数据
     */
    @Override
    public List<Map<String, Object>> muDeptBackJson(Long deptId, String workFormNo, String sdeptName) {
        return GxqWfSendBackDao.muDeptBackJson(deptId,workFormNo,sdeptName);
    }

    @Override
    public List ltSendBackMain(int wfId, String sdeptId) {
        return GxqWfSendBackDao.ltSendBackMain(wfId, sdeptId);
    }

    /**
     * 查找待分发下级工单数据
     *
     * @param deptId     部门id
     * @param workFormNo 工单编号
     * @param sdeptName  派发单位
     * @return 工单列表数据
     */
    @Override
    public List<Map<String, Object>> sendWaitListJson(Long deptId, String workFormNo, String sdeptName) {
        return getBaseMapper().sendWaitListJson(deptId,workFormNo,sdeptName);
    }

    @Override
    public List<Map<String, Object>> sendWaitListJson_gxq(Long deptId, String workFormNo, String sdeptName) {
        return getBaseMapper().sendWaitListJson_gxq(deptId,workFormNo,sdeptName);
    }

    /**
     * 查找上级不同意退回工单数据
     *
     * @param deptId 部门编号
     * @param workFormNo 工单编号
     * @param sdeptName  派发单位
     * @return 列表数据
     */
    @Override
    public List<Map<String, Object>> notPassListJson(Long deptId, String workFormNo, String sdeptName) {
        return getBaseMapper().notPassListJson(deptId,workFormNo,sdeptName);
    }

    /**
     * 查找下级退回工单数据
     *
     * @param deptId     部门编号
     * @param workFormNo
     * @param sdeptName  派发单位
     * @return 列表数据
     */
    @Override
    public List<Map<String, Object>> listSonBackJson(Long deptId, String workFormNo, String sdeptName) {
        return getBaseMapper().listSonBackJson(deptId, workFormNo, sdeptName);
    }

    /**
     * 查找承办单位已退工单数据
     * @param params 查询条件
     * @return 列表数据
     */
    @Override
    public List<Map<String, Object>> listSonAgreeBackJson(HashMap<String,Object> params) {
        return getBaseMapper().listSonAgreeBackJson(params);
    }

    @Override
    public List<Map<String, Object>> listSonAgreeBackJson_gxq(HashMap<String,Object> params) {
        return getBaseMapper().listSonAgreeBackJson_gxq(params);
    }

    /**
     * 查找承办单位未签收工单数据
     * @param params 查询条件
     * @return 列表数据
     */
    @Override
    public List<Map<String, Object>> listSonSignNotJson(HashMap<String,Object> params) {
        return getBaseMapper().listSonSignNot(params);
    }

    @Override
    public List<Map<String, Object>> listSonSignNotJson_gxq(HashMap<String,Object> params) {
        return getBaseMapper().listSonSignNot_gxq(params);
    }

    /**
     * 查找临期工单数据(差两天 超出办理期限工单)
     * @param params 查询条件
     * @return 列表数据
     */
    @Override
    public List<Map<String, Object>> muBlueSJson(HashMap<String,Object> params) {
        return getBaseMapper().muBlueSJson(params);
    }

    /**
     * 查找超期工单列表数据（超出办理期限工单）
     * @param params 查询条件
     * @return 列表数据
     */
    @Override
    public List<Map<String, Object>> muRedSJson(HashMap<String,Object> params) {
        return getBaseMapper().muRedSJson(params);
    }

    /**
     * 查找本区办理的工单列表
     *
     * @param params 查询条件
     * @return 列表数据
     */
    @Override
    public List<Map<String, Object>> rptReplyOverListJson(HashMap<String, Object> params) {
        return getBaseMapper().rptReplyOverListJson(params);
    }

    /**
     * 查找本区未转派工单列表
     *
     * @param params 查询条件
     * @return 列表数据
     */
    @Override
    public List<Map<String, Object>> rptSendWaitListJson(HashMap<String, Object> params) {
        return getBaseMapper().rptSendWaitListJson(params);
    }

    @Override
    public List<Map<String, Object>> rptSendWaitListJson_gxq(HashMap<String, Object> params) {
        return getBaseMapper().rptSendWaitListJson_gxq(params);
    }

    /**
     * 查找本区被市级拒退工单列表
     *
     * @param params 查询条件
     * @return 列表数据
     */
    @Override
    public List<Map<String, Object>> rptNotPassListJson(HashMap<String, Object> params) {
        return getBaseMapper().rptNotPassListJson(params);
    }

    /**
     * 查找本区已退工单列表
     *
     * @param params 查询条件
     * @return 列表数据
     */
    @Override
    public List<Map<String, Object>> rptDeptBackJson(HashMap<String, Object> params) {
        return getBaseMapper().rptDeptBackJson(params);
    }

    /**
     * 查找本级未签收工单列表
     *
     * @param
     * @return 列表数据
     */
    @Override
    public List<Map<String, Object>> rptSignNotJson(String sbdeptId, GxqTwfSendBackEty sendBackEty) {
        return getBaseMapper().rptSignNotJson(sbdeptId, sendBackEty);
    }

    @Override
    public List<Map<String, Object>> rptSignNotJson_gxq(String sbdeptId, GxqTwfSendBackEty sendBackEty) {
        return getBaseMapper().rptSignNotJson_gxq(sbdeptId, sendBackEty);
    }

    /**
     * 下级办理中T 列表数据
     * @param
     * @param qc
     * @return
     */
    @Override
    public List<Map<String, Object>> listSonWaitJson(QueryConditionVo qc) {
        if(!Objects.equals(qc.getFormType(),"") && qc.getFormType().equals("催办件")){
            return GxqWfSendBackDao.listSonWaitJson1(qc);
        }
        return GxqWfSendBackDao.listSonWaitJson(qc);
    }

    @Override
    public List<Map<String, Object>> listSonWaitJson_gxq(QueryConditionVo qc) {
        if(!Objects.equals(qc.getFormType(),"") && qc.getFormType().equals("催办件")){
            return GxqWfSendBackDao.listSonWaitJson1_gxq(qc);
        }
        return GxqWfSendBackDao.listSonWaitJson_gxq(qc);
    }

    /**
     * 下级已办毕T 列表数据
     * @param workFormNo
     * @param sdeptName
     * @param deptId
     * @return
     */
    @Override
    public List<Map<String, Object>> listSonOverJson(String workFormNo, String sdeptName, String deptId) {
        return GxqWfSendBackDao.listSonOverJson(workFormNo,sdeptName,deptId);
    }
    /**
     * 加载派单管理列表数据
     * @param sendBack 查询条件
     * @param deptId 部门编号
     * @return 列表数据
     */
    @Override
    public List<Map<String, Object>> sendBackJson(GxqTwfSendBackEty sendBack, Long deptId) {
        return GxqWfSendBackDao.sendBackJson(sendBack,deptId);
    }

    /**
     * 派单情况列表数据
     *
     * @param wfId 工单编号
     * @return 列表数据
     */
    @Override
    public List<GxqTwfSendBackEty> dealListJson(Integer wfId) {
        QueryWrapper<GxqTwfSendBackEty> wrapper = new QueryWrapper<>();
        wrapper.eq("wfId",wfId);
        wrapper.eq("isDel",0);
        return getBaseMapper().selectList(wrapper);
    }

    /**
     * 检查二级部门下派的派单记录是否有下级回复
     *
     * @param wfId    工单id
     * @param sdeptId 拟派部门编号
     * @return 已回复/''
     */
    @Override
    public List<CheckSendBack> checkSendBack(Integer wfId, String sdeptId) {
        return getBaseMapper().checkSendBack(wfId, sdeptId);
    }

    /**
     * 查找下级部门办理件
     *
     * @param wfId    工单id
     * @param sdeptId 部门编号
     * @return 派单列表
     */
    @Override
    public List<GxqTwfSendBackEty> listSendDeptSon(Integer wfId, Long sdeptId) {
        return getBaseMapper().listSendDeptSon(wfId, sdeptId);
    }

    @Override
    public List<GxqTwfSendBackEty> findSubDeptHandleWF(Integer wfId, Long sdeptId) {
        return getBaseMapper().findSubDeptHandleWF(wfId, sdeptId);
    }

    /**
     * 查找下级部门办理件 通过当前派单id作为pid查找
     *
     * @param pkId 派单id
     * @param sdeptId 下派部门
     * @return
     */
    @Override
    public List<GxqTwfSendBackEty> listSendSubDeptByPid(Integer pkId, Long sdeptId) {
        return getBaseMapper().listSendSubDept(pkId, sdeptId);
    }

    /**
     * 查找下级退回待处理的工单
     *
     * @param deptId     部门编号
     * @param workFormNo 工单编号
     * @param sdeptName  来源单位
     * @return 列表数据
     */
    @Override
    public List<Map<String, Object>> listSonNABackJson(Long deptId, String workFormNo, String sdeptName) {
        HashMap<String,Object> params = new HashMap<>();
        params.put("deptId",String.valueOf(deptId));
        params.put("workFormNo",workFormNo);
        params.put("sdeptName",sdeptName);
        return getBaseMapper().listSonNABackJson(params);
    }

    @Override
    public List<Map<String, Object>> listSonNABackJson_gxq(Long deptId, String workFormNo, String sdeptName) {
        HashMap<String,Object> params = new HashMap<>();
        params.put("deptId",String.valueOf(deptId));
        params.put("workFormNo",workFormNo);
        params.put("sdeptName",sdeptName);
        return getBaseMapper().listSonNABackJson_gxq(params);
    }

    /**
     * 查找下级退回已处理的工单
     *
     * @param deptId     部门编号
     * @param workFormNo 工单编号
     * @param sdeptName  来源单位
     * @return 列表数据
     */
    @Override
    public List<Map<String, Object>> listSonABackJson(Long deptId, String workFormNo, String sdeptName) {
        HashMap<String,Object> params = new HashMap<>();
        params.put("deptId",String.valueOf(deptId));
        params.put("workFormNo",workFormNo);
        params.put("sdeptName",sdeptName);
        return getBaseMapper().listSonABackJson(params);
    }

    /**
     * 查找下级退回已处理的工单
     * @return 列表数据
     */
    @Override
    public List<Map<String, Object>> listAllSonABackJson(QueryConditionVo qc) {
        HashMap<String,Object> params = new HashMap<>();
        params.put("deptId",qc.getUserDeptId());
        params.put("workFormNo",qc.getWorkFormNO());
        params.put("sdeptName",qc.getSdeptName());
        params.put("timeDefault",qc.getTimeDefault());
        params.put("beginTime",qc.getBeginTime());
        params.put("endTime",qc.getEndTime());
        return getBaseMapper().listAllSonABackJson(params);
    }

    /**
     * 查询下级部门的电话未签收、未回复、退回和超期情况数据统计
     *  2023/1/3
     *  @Param params
     */
    @Override
    public List<Map<String, Object>> listTelSubStatisticsJson(HashMap<String, Object> params) {
        Object deptId = params.get("deptId");
        boolean flag = (boolean) params.get("flag");
        String s = deptId.toString();
//        if (s.length()>3&&s.startsWith("304")){
//            s = "301"+s.substring(3,6);
//            long finalDeptId = Long.parseLong(s);
//            params.put("deptId",finalDeptId);
//        }
//        return getBaseMapper().listTelSubStatisticsJson(params);
        if (flag){
            return getBaseMapper().listTelSubStatistics_gxq(s);
        }else{
            return getBaseMapper().listTelSubStatistics(s);
        }
    }

    /**
     * 市级已删除电话工单
     * @param GxqTwfSendBackEty
     * @param deptId
     * @return
     */
    @Override
    public List<Map<String,Object>> deleteTelWFJson(GxqTwfSendBackEty GxqTwfSendBackEty, String deptId) {
        List<Map<String,Object>> sendBackList = GxqWfSendBackDao.deletedTelWFList(GxqTwfSendBackEty, deptId);
//        List<Map<String, Object>> orderNums = GxqWfSendBackDao.sendOrderNums(GxqTwfSendBackEty, deptId);
//        for (Map<String, Object> map1 : orderNums) {
//            for (Map<String, Object> map2 : sendBackList) {
//                if (map1.get("myTwfNO").equals(map2.get("myTwfNO"))) {
//                    map2.put("sendOrderNum",map1.get("sendOrderNum"));
//                }
//            }
//        }
        return sendBackList;
    }

    @Override
    public boolean updateUrgeTransact(String sbId) {
        return GxqWfSendBackDao.updateUrgeTransact(sbId) > 0;
    }

    /**
     * 下级已办毕T 待处理列表数据
     * @param workFormNo
     * @param sbDeptName
     * @param deptId
     * @return
     */
    @Override
    public List<Map<String, Object>> listSonOverUntreatedJson(String workFormNo, String sbDeptName, String deptId) {
        return GxqWfSendBackDao.listSonOverUntreatedJson(workFormNo,sbDeptName,deptId);
    }

    @Override
    public List<Map<String, Object>> listSonOverUntreatedJson_gxq(String workFormNo, String sbDeptName, String deptId) {
        return GxqWfSendBackDao.listSonOverUntreatedJson_gxq(workFormNo,sbDeptName,deptId);
    }

    /**
     * 下级已办毕T 已处理列表数据
     * @param workFormNo
     * @param sbDeptName
     * @param deptId
     * @return
     */
    @Override
    public List<Map<String, Object>> listSonOverTreatedJson(String workFormNo, String sbDeptName, String deptId) {
        return GxqWfSendBackDao.listSonOverTreatedJson(workFormNo,sbDeptName,deptId);
    }

    private List<Map<String, Object>> workOrderType(List<Map<String, Object>> waitReplyList, String isType) {
        List<Map<String, Object>> urgeList = new ArrayList<>();//催办
        List<Map<String, Object>> adventList = new ArrayList<>();//临期
        List<Map<String, Object>> overList = new ArrayList<>();//超期
        List<Map<String, Object>> commonList = new ArrayList<>();//普通
        if (isType != null && waitReplyList != null) {
            String[] now = DateUtils.getDate().split("-");
            String[] deadLine = null;
            for (Map<String, Object> map : waitReplyList) {
                Object isUrge = map.get("isUrge");
                if (isUrge !=null && isUrge.equals(1)) {
                    urgeList.add(map);
                }else{
                    String oldDate = (String)map.get("bkLimit");
                    if(oldDate != null){
                        deadLine = oldDate.split("-");
                        int year = Integer.parseInt(now[0]);
                        int dlYear = Integer.parseInt(deadLine[0]);
                        if(dlYear == year){//年份相同
                            int month = Integer.parseInt(now[1]);
                            int dlMonth = Integer.parseInt(deadLine[1]);
                            if(dlMonth == month){//月份相同
                                int day = Integer.parseInt(now[2]);
                                int dlDay = Integer.parseInt(deadLine[2]);
                                if(dlDay > day && (dlDay-day) > 2){
                                    commonList.add(map); //普通件
                                } else if (dlDay < day) {
                                    overList.add(map); //超期件
                                } else {
                                    adventList.add(map); //临期键
                                }
                            }else if(dlMonth < month){
                                overList.add(map); //超期件
                            } else {
                                commonList.add(map); //普通件
                            }
                        }else if(dlYear < year){
                            overList.add(map); //超期件
                        } else {
                            commonList.add(map); //普通件
                        }
                    }
                }

            }
            switch (isType) {
                case "催办件":
                    return urgeList;
                case "临期键":
                    return adventList;
                case "超期件":
                    return overList;
                case "普通件":
                    return commonList;
            }
        }
        return waitReplyList;
    }

    /**
     * 市级未签收列表数据
     * @param GxqTwfSendBackEty
     * @param
     * @return
     */
    @Override
    public List<GxqTwfSendBackEty> notSignList(GxqTwfSendBackEty GxqTwfSendBackEty, String deptId) {
        return GxqWfSendBackDao.notSignList(GxqTwfSendBackEty,deptId);
    }

    /**
     * 查找审核本级回复的工单数据
     *
     * @param sdeptName
     * @return 工单列表数据
     */
    @Override
    public List<Map<String, Object>> waitReplyListJson(GxqTwfSendBackEty GxqTwfSendBackEty, String sdeptName) {
            return GxqWfSendBackDao.waitReplyListJson(GxqTwfSendBackEty,sdeptName);
    }

    @Override
    public GxqTwfSendBackEty curDeptHandleSend(Integer wfId, String deptId) {
        return GxqWfSendBackDao.curDeptHandleSend(wfId,deptId);
    }

    /**
     * 查询未处理电话工单数据
     * @param deptId 办理部门
     * @param GxqTwfSendBackEty 电话工单
     * @return
     */
    @Override
    public List<Map<String, Object>> notHandleTelJson(String deptId, GxqTwfSendBackEty GxqTwfSendBackEty) {
        return GxqWfSendBackDao.notHandleTelJson(deptId,GxqTwfSendBackEty);
    }

    @Override
    public List<Map<String, Object>> notHandleTelJson_gxq(String deptId, GxqTwfSendBackEty GxqTwfSendBackEty) {
        return GxqWfSendBackDao.notHandleTelJson_gxq(deptId,GxqTwfSendBackEty);
    }

    /**
     * 导出未处理电话工单数据
     * @param deptId 办理部门
     * @return
     */
    @Override
    public List<NotHandleTelExcel> notHandleTelExport(String deptId) {
        return GxqWfSendBackDao.notHandleTelExport(deptId);
    }

    /**
     * 上级催办电话数据
     * @param deptId 办理部门
     * @param GxqTwfSendBackEty 电话派单
     * @return
     */
    @Override
    public List<Map<String, Object>> supUrgeTelOrderJson(String deptId, GxqTwfSendBackEty GxqTwfSendBackEty) {
        return GxqWfSendBackDao.supUrgeTelOrderJson(deptId,GxqTwfSendBackEty);
    }

    /**
     * 查询上级催办电话工单数据
     * @param deptId 办理部门
     * @return
     */
    @Override
    public List<SupUrgeTelExcel> supUrgeTelOrderExport(String deptId) {
        return GxqWfSendBackDao.supUrgeTelOrderExport(deptId);
    }

    @Override
    public List<Map<String, Object>> subDeptTelDetailJson(String subDeptId,GxqTwfSendBackEty GxqTwfSendBackEty) {
        return GxqWfSendBackDao.subDeptTelDetailJson(subDeptId,GxqTwfSendBackEty);
    }

    @Override
    public List<Map<String, Object>> subDeptTelDetailJson_gxq(String subDeptId,GxqTwfSendBackEty GxqTwfSendBackEty) {
        return GxqWfSendBackDao.subDeptTelDetailJson_gxq(subDeptId,GxqTwfSendBackEty);
    }

    /**
     * 查询临期工单数量
     * 高新区
     * @param deptId 部门编号
     * @return 临期工单数量
     */
    @Override
    public int dueWorkOrderCount(String deptId) {
        return getBaseMapper().dueWorkOrderCount(deptId);
    }

    /**
     * 查找待本部门回复的工单数据
     * 高新区
     * @param deptId 部门编号
     * @param qc 查询参数
     * @return 工单列表数据
     */
    @Override
    public List<Map<String, Object>> muReplyWaitJson_gxq(Long deptId, QueryConditionVo qc) {
        return getBaseMapper().muReplyWaitJson_gxq(MapDataUtil.multiTypeParamListToMap(qc,String.valueOf(deptId)));
    }

    /**
     * 查找审核本级回复的工单总数
     *
     * @param deptId     部门id
     * @return 工单列表数据
     */
    @Override
    public Integer countMuReplyChkJson(Long deptId) {
        Integer muReplyChkCount = GxqWfSendBackDao.countMuReplyChkJson(deptId);
        return muReplyChkCount == null ? 0 : muReplyChkCount;
    }

    /**
     * 获取审核本级回复的工单数据
     * @param userNo 用户id
     * @param deptId 部门id
     * @param queryConditionVo
     * @return
     */
    @Override
    public List<Map<String, Object>> getMuReplyChkJson(Long userNo, Long deptId, QueryConditionVo queryConditionVo) {
        return GxqWfSendBackDao.getMuReplyChkJson(userNo,deptId,queryConditionVo);
    }

    /**
     * 查找审核本级回复的工单数据
     * @param deptId 部门id
     * @param queryConditionVo 查询参数
     * @return
     */
    @Override
    public List<Map<String, Object>> muReplyChkJsonData(Long deptId, QueryConditionVo queryConditionVo) {
        return GxqWfSendBackDao.muReplyChkJsonData(MapDataUtil.multiTypeParamListToMap(queryConditionVo,deptId.toString()));
    }

    /**
     * 查找本部门已办毕的工单数据
     * @param deptId 部门id
     * @param queryConditionVo 查询参数
     * @return 工单列表数据
     */
    @Override
    public List<Map<String, Object>> muReplyOverJsonData(Long deptId, QueryConditionVo queryConditionVo) {
        return GxqWfSendBackDao.muReplyOverJsonData(String.valueOf(deptId),queryConditionVo);
    }

    /**
     * 加载(区县)退回的工单T列表数据
     * 高新区
     * @param
     * @param queryConditionVo 查询参数
     * @return 列表数据
     */
    @Override
    public List<Map<String, Object>> backPeerDeptAuditTJson(Long sdeptId, QueryConditionVo queryConditionVo) {
        return GxqWfSendBackDao.backPeerDeptAuditTJson(sdeptId, queryConditionVo);
    }

    @Override
    public List<Map<String, Object>> backPeerDeptAuditTJson_gxq(Long sdeptId, QueryConditionVo queryConditionVo) {
        return GxqWfSendBackDao.backPeerDeptAuditTJson_gxq(MapDataUtil.multiTypeParamListToMap(queryConditionVo,sdeptId.toString()));
    }

    /**
     * 加载上级不同意退回列表数据
     * 高新区
     * @param deptId 部门编号
     * @param queryConditionVo 查询参数
     * @return 列表数据
     */
    @Override
    public List<Map<String, Object>> peerDeptNotPassListJson(Long deptId, QueryConditionVo queryConditionVo) {
        return getBaseMapper().peerDeptNotPassListJson(deptId,queryConditionVo);
    }

    /**
     * 获取待本级回复的列表
     * @param num 获取数量
     * @param sbdeptId 承办部门
     * @return
     */
    @Override
    public List<GxqTwfSendBackEty> getAWaitPeerReplyList(Integer num, String sbdeptId) {
        return getBaseMapper().getAWaitPeerReplyList(num, sbdeptId);
    }

    /**
     * 查找待本部门回复的工单数据导出
     * 高新区
     * @param deptId 部门id
     * @return 工单列表数据
     */
    @Override
    public List<GxqMuReplyWaitTelExcel> muReplyWaitJsonExport_gxq(Long deptId, QueryConditionVo qc) {
        return GxqWfSendBackDao.muReplyWaitJson_gxqExport(MapDataUtil.multiTypeParamListToMap(qc,String.valueOf(deptId)));
    }
}
